home *** CD-ROM | disk | FTP | other *** search
/ Aminet 38 / Aminet 38 (2000)(Schatztruhe)[!][Aug 2000].iso / Aminet / util / moni / Scout-src.lha / src / objects / scout_tasks.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-03-09  |  27.5 KB  |  766 lines
  1. /**
  2.  * Scout - The Amiga System Monitor
  3.  *
  4.  *------------------------------------------------------------------
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * You must not use this source code to gain profit of any kind!
  21.  *
  22.  *------------------------------------------------------------------
  23.  *
  24.  * @author Andreas Gelhausen
  25.  * @author Richard Körber <rkoerber@gmx.de>
  26.  */
  27.  
  28.  
  29.  
  30. #include "scout_tasks.h"
  31.  
  32. extern struct ExecBase  *SysBase;
  33.  
  34. int  taskcnt;
  35. APTR taskmoretext0,taskmoretext1a,taskmoretext1b,taskmoretext2,taskmoretext3;
  36. APTR procmorelist;
  37. APTR processmoretext0,processmoretext1a,processmoretext1b,processmoretext2,processmoretext3;
  38. APTR processmoretext4,processmoretext5,processmoretext6a,processmoretext6b,processmoretext7;
  39. struct Remember *TaskRememberKey;
  40.  
  41. struct SignalSemaphore *patchsem = NULL;
  42. VOID __asm (*cleartaskdata) (VOID) = NULL;
  43. LONG  __asm (*gettaskdata) (register __d0 struct Task *) = NULL;
  44. struct Task * __asm (*getaddedtask) (VOID) = NULL;
  45. char  *switchstate = NULL;
  46.  
  47. LONG totalmicros,cpuseconds = 1,cpumicros = 0;
  48.  
  49. #define CHEATSTACKSIZE  1024
  50. #define CHEATTASKNAME   "« Scout's cheat task »"
  51. struct Task *cheattask = NULL;
  52.  
  53. static void cheattask_func (void) {
  54.    while (TRUE) {}
  55. }
  56.  
  57. struct Task * AddCheatTask (void) {
  58.    struct Task *result;
  59.  
  60.    if (result = AllocMem (CHEATSTACKSIZE + sizeof (struct Task), MEMF_ANY|MEMF_CLEAR)) {
  61.       result->tc_SPLower = sizeof (struct Task) + (char *) result;
  62.       result->tc_SPUpper = CHEATSTACKSIZE + sizeof (struct Task) + (char *) result;
  63.       result->tc_SPReg = result->tc_SPUpper;
  64.  
  65.       result->tc_Node.ln_Name = CHEATTASKNAME;
  66.       result->tc_Node.ln_Pri = -128;
  67.       result->tc_Node.ln_Type = NT_TASK;
  68.  
  69.       AddTask (result, (APTR) &cheattask_func, NULL);
  70.    }
  71.    return (result);
  72. }
  73.  
  74. void RemoveCheatTask (void) {
  75.    RemTask (cheattask);
  76.    FreeMem (cheattask, CHEATSTACKSIZE + sizeof (struct Task));
  77.    cheattask = NULL;
  78. }
  79.  
  80. struct Task * TaskExists (struct Task *tasktofind) {
  81.    struct   Task  *task, *result = NULL;
  82.  
  83.    if ((tasktofind == (struct Task *) 42) || (tasktofind == myprocess))
  84.       return (myprocess);
  85.  
  86.    Forbid();
  87.  
  88.    task = FIRSTTASKREADY;
  89.    while (task->tc_Node.ln_Succ != 0) {
  90.       if (task == tasktofind)
  91.          result = task;
  92.       task = (struct Task *) task->tc_Node.ln_Succ;
  93.    }
  94.  
  95.    task = FIRSTTASKWAIT;
  96.    while (task->tc_Node.ln_Succ != 0) {
  97.       if (task == tasktofind)
  98.          result = task;
  99.       task = (struct Task *) task->tc_Node.ln_Succ;
  100.    }
  101.  
  102.    Permit();
  103.    return (result);
  104. }
  105.  
  106. void HandleTimerRequest (BOOL waitstate) {
  107.    struct Window *taskwin;
  108.  
  109.    if (! waitstate) {
  110.       AbortIO ((struct IORequest *) &TimerIORequest);
  111.    }
  112.  
  113.    if ((patchsem) && (*switchstate)) {
  114.       if (((waitstate) && (TimerIORequest.tr_node.io_Message.mn_Node.ln_Type != NT_MESSAGE)) \
  115.          || (! waitstate)) {
  116.          (*cleartaskdata) ();
  117.  
  118.          if (WI_Tasks) {
  119.             TimerIORequest.tr_time.tv_secs = cpuseconds;
  120.             TimerIORequest.tr_time.tv_micro = cpumicros;
  121.             TimerIORequest.tr_node.io_Command = TR_ADDREQUEST;
  122.             SendIO ((struct IORequest *) &TimerIORequest);
  123.  
  124.             get (WI_Tasks, MUIA_Window_Window, &taskwin);
  125.             if (taskwin)
  126.                UpdateTasks();
  127.          }
  128.       }
  129.    }
  130. }
  131.  
  132. void CheckCPUUsage (void) {
  133.    ULONG    size;
  134.  
  135.    get (CY_CpuUsage,MUIA_Cycle_Active,&updatetimestate);
  136.  
  137.    if (updatetimestate) {
  138.       Forbid();
  139.       if (patchsem = FindSemaphore ((UBYTE *) &SemaphoreName)) {
  140.          CodeAddress = sizeof (struct SignalSemaphore) + 8 + (char *) patchsem;
  141.          Permit();
  142.       } else {
  143.          Permit();
  144.          size = (ULONG) ((char *) &CodeAddress - (char *) &MySwitch + 8);
  145.  
  146.          if (AsmTimerBase = (struct Library *) FindName (&SysBase->DeviceList, TIMER_DEVNAME)) {
  147.             if (patchsem = AllocMem (sizeof (struct SignalSemaphore) + 8 + size, MEMF_ANY|MEMF_CLEAR)) {
  148.                Forbid();
  149.                FreeMem (patchsem, sizeof (struct SignalSemaphore) + 8 + size);
  150.                patchsem = AllocMem (sizeof (struct SignalSemaphore) + 8 + size, MEMF_ANY|MEMF_CLEAR|MEMF_REVERSE);
  151.                Permit();
  152.  
  153.                if (patchsem) {
  154.                   CodeAddress = sizeof (struct SignalSemaphore) + 8 + (char *) patchsem;
  155.                   OldSwitch = *((ULONG *) (-52 + (char *) SysBase));
  156.                   OldAdd = *((ULONG *) (-280 + (char *) SysBase));
  157.  
  158.                   CopyMem (&MySwitch, (APTR) CodeAddress, size);
  159.  
  160.                   patchsem->ss_Link.ln_Name = (char *) &SemaphoreName - (char *) &MySwitch + CodeAddress;
  161.                   patchsem->ss_Link.ln_Type = NT_SIGNALSEM;
  162.                   AddSemaphore (patchsem);
  163.  
  164. //                  cleartaskdata = (VOID (* __asm) (VOID)) ((char *) &ClearTaskData - (char *) &MySwitch + CodeAddress);
  165. //                  gettaskdata = (LONG (* __asm)(register __d0 struct Task *)) ((char *) &GetTaskData - (char *) &MySwitch + CodeAddress);
  166. //                  getaddedtask = (struct Task *(* __asm)(VOID)) ((char *) &GetAddedTask - (char *) &MySwitch + CodeAddress);
  167.  
  168.                   SetPatches();
  169.                   ShowTasks();
  170.                }
  171.             }
  172.          } else {
  173.             aprintf ("Couldn't find %ls!\n", TIMER_DEVNAME);
  174.          }
  175.       }
  176.    }
  177.  
  178.         if (patchsem) {
  179.       cleartaskdata = (VOID (* __asm) (VOID)) ((char *) &ClearTaskData - (char *) &MySwitch + CodeAddress);
  180.       gettaskdata = (LONG (* __asm)(register __d0 struct Task *)) ((char *) &GetTaskData - (char *) &MySwitch + CodeAddress);
  181.       getaddedtask = (struct Task *(* __asm)(VOID)) ((char *) &GetAddedTask - (char *) &MySwitch + CodeAddress);
  182.       switchstate = (char *) &SwitchState - (char *) &MySwitch + CodeAddress;
  183.  
  184.            *switchstate = (char) updatetimestate;
  185.            HandleTimerRequest (FALSE);
  186.  
  187.       if (updatetimestate == 2) {
  188.          if (! cheattask)
  189.             cheattask = AddCheatTask();
  190.       } else {
  191.          if (cheattask)
  192.             RemoveCheatTask();
  193.          set(cpucount,MUIA_Gauge_Current,0);
  194.          set(cpucount,MUIA_Gauge_InfoText,"\0330-----");
  195. //*         MySetContents (cpucount, ESC "c-----");
  196.       }
  197.         }
  198. }
  199.  
  200. char * GetTaskState (UBYTE state) {
  201.    char *TaskStateText[] = {
  202.       "frozen","added","run","ready","wait","except","removed",
  203.       "invalid","< ??? >"
  204.    };
  205.  
  206.    UBYTE TaskState[] = {
  207.       TS_FROZEN,TS_ADDED,TS_RUN,TS_READY,TS_WAIT,TS_EXCEPT,TS_REMOVED,
  208.       TS_INVALID
  209.    };
  210.  
  211.    int i = 0;
  212.  
  213.    while (TaskState[i]) {
  214.       if (state == TaskState[i]) {
  215.          return (TaskStateText[i]);
  216.       }
  217.       i++;
  218.    }
  219.    if (TaskState[i] == TS_INVALID) {
  220.       return (TaskStateText[i]);
  221.    } else {
  222.       return (TaskStateText[i+1]);
  223.    }
  224. }
  225.  
  226. char * GetNodeType (UBYTE type) {
  227.    char *NodeTypeText[] = {
  228.       "task","interrupt","device","msgport",
  229.       "message","freemsg","replymsg","resource","library",
  230.       "memory","softint","font","process","semaphore",
  231.       "signalsem","bootnode","kickmem","graphics",
  232.       "deathmessage","user","extended",
  233.       "unknown","< ??? >"
  234.    };
  235.  
  236.    UBYTE NodeType[] = {
  237.       NT_TASK,NT_INTERRUPT,NT_DEVICE,NT_MSGPORT,
  238.       NT_MESSAGE,NT_FREEMSG,NT_REPLYMSG,NT_RESOURCE,
  239.       NT_LIBRARY,NT_MEMORY,NT_SOFTINT,NT_FONT,NT_PROCESS,
  240.       NT_SEMAPHORE,NT_SIGNALSEM,NT_BOOTNODE,NT_KICKMEM,
  241.       NT_GRAPHICS,NT_DEATHMESSAGE,NT_USER,NT_EXTENDED,
  242.       NT_UNKNOWN
  243.    };
  244.  
  245.    int i = 0;
  246.  
  247.    while (NodeType[i]) {
  248.       if (type == NodeType[i]) {
  249.          return (NodeTypeText[i]);
  250.       }
  251.       i++;
  252.    }
  253.    if (NodeType[i] == NT_UNKNOWN)
  254.       return (NodeTypeText[i]);
  255.    else
  256.       return (NodeTypeText[i+1]);
  257. }
  258.  
  259. __asm LONG tasklist_dspfunc(register __a2 char **array, register __a1 struct TaskEntry *taskentry, register __a0 struct Hook *hook) {
  260.    if (taskentry) {
  261.       *array++ = taskentry->ts_address;
  262.       *array++ = taskentry->ts_type;
  263.       *array++ = taskentry->ts_pri;
  264.       *array++ = taskentry->ts_num;
  265.       *array++ = taskentry->ts_state;
  266.       *array++ = taskentry->ts_sigwait;
  267.       *array++ = taskentry->ts_cpu;
  268.       *array++ = taskentry->ts_name;
  269.       *array   = NULL;
  270.    } else {
  271.       *array++ = ESC "bAddress";
  272.       *array++ = ESC "bln_Type";
  273.       *array++ = ESC "bln_Pri";
  274.       *array++ = ESC "bNUM";
  275.       *array++ = ESC "bState";
  276.       *array++ = ESC "bSigWait";
  277.       *array++ = ESC "bCPU %";
  278.       *array++ = ESC "bln_Name";
  279.       *array++ = NULL;
  280.    }
  281.    return (0);
  282. }
  283.  
  284. struct Hook tasklist_dsphook = {
  285.  {NULL, NULL},
  286.  (ULONG (* )())tasklist_dspfunc,
  287.  NULL, NULL
  288. };
  289.  
  290. void FreeTasks (void) {
  291.    MyFreeStructs (&TaskRememberKey, tasktext, tasklist);
  292. }
  293.  
  294. char * GetTaskName (struct Task *task) {
  295.    struct CommandLineInterface   *cli;
  296.    int   lauf = 0;
  297. //   int   offset = 0;
  298.    char  *pointer;
  299.    char  *error = "<notask>";
  300.  
  301.    if (task) {
  302.       if ((task->tc_Node.ln_Type == NT_PROCESS) && (((struct Process *) task)->pr_CLI != 0)) {
  303.          cli = (struct CommandLineInterface *) (((struct Process *) task)->pr_CLI << 2);
  304.          if ((pointer = (char *) cli->cli_CommandName) &&
  305.              (pointer = (char *) (((LONG) pointer) << 2) + 1) &&
  306.              (pointer[0])) {
  307.  
  308.             while (pointer[lauf]) {
  309.                if (pointer[lauf++] != ' ')
  310.                   return (pointer);
  311.             }
  312. /*
  313.             pointer = (char *) (((LONG) pointer) << 2);
  314.  
  315.             while (*(pointer + lauf) != '\0') {
  316.                if ((*(pointer + lauf) == '/') || ((*(pointer + lauf) == ':') && (*(pointer + lauf + 1) != '\0'))) {
  317.                   offset = lauf;
  318.                }
  319.                lauf++;
  320.             }
  321.             if (lauf)
  322.                return (pointer + 1 + offset);
  323. */
  324.          }
  325.       }
  326.       if (((task->tc_Node.ln_Type == NT_PROCESS) || (task->tc_Node.ln_Type == NT_TASK)) \
  327.           && (task->tc_Node.ln_Succ)) {
  328.          return (task->tc_Node.ln_Name);
  329.       } else {
  330.          return (error);
  331.       }
  332.    }
  333.    return (NULL);
  334. }
  335.  
  336. void GetTaskNumber (struct Task *task, char string[]) {
  337.    if ((task->tc_Node.ln_Type == NT_TASK) || (((struct Process *)task)->pr_TaskNum == 0)){
  338.       strcpy (string, "---");
  339.    } else {
  340.       sprintf (string, "%ld", ((struct Process *) task)->pr_TaskNum);
  341.    }
  342. }
  343.  
  344. void GetTaskEntry (struct Task *task, struct TaskEntry *taskentry, BOOL cpuflag) {
  345.    char  tasknum[4];
  346.    ULONG  cpu,zehntel;
  347.  
  348.    if (! taskentry->ts_ptr) {
  349.       taskentry->ts_ptr = task;
  350.  
  351.       sprintf (taskentry->ts_address, "$%08lx", task);
  352.       strcpy (taskentry->ts_type, GetNodeType (task->tc_Node.ln_Type));
  353.       GetTaskNumber (task, tasknum);
  354.       strncpy (taskentry->ts_num, tasknum, 3);
  355.    }
  356.  
  357.    sprintf (taskentry->ts_pri, "%4ld ", task->tc_Node.ln_Pri);
  358.    strcpy (taskentry->ts_state, GetTaskState ((UBYTE) task->tc_State));
  359.    sprintf (taskentry->ts_sigwait, "$%08lx", task->tc_SigWait);
  360.    strncpy (taskentry->ts_name, nonetest (GetTaskName (task)), NODENAMELENGTH);
  361.    healstring (taskentry->ts_name);
  362.  
  363.    if ((cpuflag) && (totalmicros = *((ULONG *) ((char *) &TotalMicros1 + 4 - (char *) &MySwitch + CodeAddress)))) {
  364.       cpu = (*gettaskdata)(task);
  365.  
  366.       if (!(zehntel = UDivMod32 (totalmicros, 1000)))
  367.          zehntel = 1;
  368.  
  369.       zehntel = UDivMod32 (cpu, zehntel);
  370.       cpu = UDivMod32 (zehntel, 10);
  371.       zehntel -= UMult32 (cpu, 10);
  372.                 if (cpu > 99) {
  373.                         cpu = 100;
  374.                         zehntel = 0;
  375.                 }
  376.       sprintf (taskentry->ts_cpu, "%ld.%ld", cpu, zehntel);
  377.    } else {
  378.       strcpy (taskentry->ts_cpu, "0.0");
  379.    }
  380. }
  381.  
  382. void UpdateTasks (void) {
  383.    struct   TaskEntry   *taskentry,*cmptaskentry;
  384.    struct   Task        *task;
  385.    int      i;
  386.    ULONG    cheatcpu;
  387.  
  388.    while (task = (*getaddedtask) ()) {
  389.       if (TaskExists (task) && (taskentry = AllocRemember (&TaskRememberKey, sizeof (struct TaskEntry), MEMF_ANY|MEMF_CLEAR))) {
  390.          GetTaskEntry (task, taskentry, TRUE);
  391.          InsertSortedEntry (tasklist, (APTR *) &taskentry);
  392.          SetCountText (taskcount, ++taskcnt);
  393.       }
  394.    }
  395.  
  396.    if (cmptaskentry = AllocMem (sizeof (struct TaskEntry), MEMF_ANY|MEMF_CLEAR)) {
  397.       for (i=0;;i++) {
  398.          DoMethod (tasklist,MUIM_List_GetEntry,i,&taskentry);
  399.  
  400.          if (taskentry) {
  401.             if (task = TaskExists ((struct Task *) taskentry->ts_ptr)) {
  402.                CopyMem (taskentry, cmptaskentry, sizeof (struct TaskEntry));
  403.                GetTaskEntry (task, taskentry, TRUE);
  404.                if (memcmp (taskentry,cmptaskentry, sizeof (struct TaskEntry))) {
  405.                   DoMethod (tasklist,MUIM_List_Redraw,i);
  406.                }
  407.             } else {
  408.                if (! (task = TaskExists ((struct Task *) taskentry->ts_ptr))) {
  409.                   DoMethod (tasklist, MUIM_List_Remove, i--);
  410.                   SetCountText (taskcount, --taskcnt);
  411.                }
  412.             }
  413.          } else {
  414.             break;
  415.          }
  416.       }
  417.       FreeMem (cmptaskentry, sizeof (struct TaskEntry));
  418.    }
  419.  
  420.    if (updatetimestate == 2) {
  421.       cheatcpu = (*gettaskdata)(cheattask);
  422.       if (totalmicros) {
  423.          set(cpucount,MUIA_Gauge_InfoText,"%ld %%");
  424.          set(cpucount,MUIA_Gauge_Current,UDivMod32 (UMult32 (totalmicros - cheatcpu, 100), totalmicros));
  425. //*         MySetContents (cpucount, ESC "r%ld \%", UDivMod32 (UMult32 (totalmicros - cheatcpu, 100), totalmicros));
  426.       }
  427.    }
  428. }
  429.  
  430. int GetTasks (struct TaskEntry **first) {
  431.    #define maxtasknumber 512
  432.  
  433.    struct   Task        *task;
  434.    struct   TaskEntry   *taskentry,*previous = NULL;
  435.    unsigned long        *buffer,maxcnt,loopcnt;
  436.  
  437.    int taskcnt = 0;
  438.    *first = 0;
  439.  
  440.    if (clientstate) {
  441.       if (SendDaemon ("GetTaskList")) {
  442.          while ((taskentry = AllocRemember (&TaskRememberKey, sizeof (struct TaskEntry), MEMF_ANY|MEMF_CLEAR)) \
  443.            && (ReceiveDecodedEntry ((UBYTE *) taskentry, sizeof (struct TaskEntry)))) {
  444.             IsHex (taskentry->ts_address, (long *) &taskentry->ts_ptr);
  445.  
  446.             if (! *first)
  447.                *first = taskentry;
  448.             if (previous)
  449.                previous->ts_next = taskentry;
  450.  
  451.             taskcnt++;
  452.             previous = taskentry;
  453.          }
  454.       }
  455.    } else {
  456.       loopcnt = 0;
  457.       maxcnt = maxtasknumber;
  458.    
  459.       if (buffer = AllocMem ((maxtasknumber+1)<<2, MEMF_ANY|MEMF_CLEAR)) {
  460.          Forbid();
  461.    
  462.          task = FIRSTTASKREADY;
  463.          while ((task->tc_Node.ln_Succ != 0) && (maxcnt)) {
  464.             buffer[taskcnt++] = (ULONG) task;
  465.             maxcnt--;
  466.             task = (struct Task *)task->tc_Node.ln_Succ;
  467.          }
  468.    
  469.          task = FIRSTTASKWAIT;
  470.          while ((task->tc_Node.ln_Succ != 0) && (maxcnt)) {
  471.             buffer[taskcnt++] = (ULONG) task;
  472.             maxcnt--;
  473.             task = (struct Task *)task->tc_Node.ln_Succ;
  474.          }
  475.    
  476.          Permit();
  477.          while ((buffer[loopcnt]) && (taskentry = AllocRemember (&TaskRememberKey, sizeof (struct TaskEntry), MEMF_ANY|MEMF_CLEAR))) {
  478.             if (! *first)
  479.                *first = taskentry;
  480.             if (previous)
  481.                previous->ts_next = taskentry;
  482.    
  483.             GetTaskEntry ((struct Task *) buffer[loopcnt++], taskentry, FALSE);
  484.             previous = taskentry;
  485.          }
  486.          FreeMem (buffer, (maxtasknumber+1)<<2);
  487.    
  488.          if (taskentry = AllocRemember (&TaskRememberKey, sizeof (struct TaskEntry), MEMF_ANY|MEMF_CLEAR)) {
  489.             if (previous)
  490.                previous->ts_next = taskentry;
  491.    
  492.             GetTaskEntry (myprocess, taskentry, FALSE);
  493.             taskentry->ts_ptr = (struct Task *) 42;  // 42, damit Scouts Prozess oben in der Liste steht!
  494.             taskcnt++;
  495.             previous = taskentry;
  496.          }
  497.       }
  498.    }
  499.    return (taskcnt);
  500. }
  501.  
  502. void PrintTasks (char *filename) {
  503.    int   i=1;
  504.    BPTR  handle;
  505.    struct TaskEntry *entryp;
  506.  
  507.    handle = HandlePrintStart (filename);
  508.    if ((handle) && (PrintOneLine (handle, "\n  Address  Type     Pri NUM State    SigWait  Name\n\n"))) {
  509.       if (! WI_Tasks) {
  510.          i = GetTasks (&entryp);
  511.       }
  512.       if (i) {
  513.          for (i=0;;i++) {
  514.             if (WI_Tasks)
  515.                DoMethod (tasklist,MUIM_List_GetEntry,i,&entryp);
  516.             if (!entryp) break;
  517.  
  518.             sprintf (tmpstr2, " %ls %-7.7ls %4ls%3ls %-7.7ls %ls %ls\n", entryp->ts_address, entryp->ts_type, entryp->ts_pri, entryp->ts_num, entryp->ts_state, entryp->ts_sigwait, entryp->ts_name);
  519.             if (! (PrintOneLine (handle, tmpstr2)))
  520.                break;
  521.  
  522.             if (! WI_Tasks)
  523.                entryp = entryp->ts_next;
  524.          }
  525.       }
  526.    }
  527.    HandlePrintStop();
  528. }
  529.  
  530. void ShowTasks (void) {
  531.    #define maxtasknumber 512
  532.  
  533.    struct   TaskEntry   *task;
  534.  
  535.    ApplicationSleep();
  536.    set(tasklist,MUIA_List_Quiet,TRUE);
  537.    set(tasklist,MUIA_List_CompareHook,tasklist_cmphook_ptr);
  538.    set(BT_TaskRemove, MUIA_Disabled, TRUE);
  539.    set(BT_TaskFreeze, MUIA_Disabled, TRUE);
  540.    set(BT_TaskActivate, MUIA_Disabled, TRUE);
  541.    set(BT_TaskPriority, MUIA_Disabled, TRUE);
  542.    set(BT_TaskSignal, MUIA_Disabled, TRUE);
  543.    set(BT_TaskBreak, MUIA_Disabled, TRUE);
  544.    set(BT_TaskMore, MUIA_Disabled, TRUE);
  545.  
  546.    if (clientstate) {
  547.       set(CY_CpuUsage, MUIA_Disabled, TRUE);
  548.    }
  549.    FreeTasks();
  550.  
  551.    taskcnt = GetTasks (&task);
  552.  
  553.    while (task) {
  554.       InsertSortedEntry (tasklist, (APTR *) &task);
  555.       task = task->ts_next;
  556.    }
  557.  
  558.    SetCountText (taskcount, taskcnt);
  559.    AwakeApplication();
  560.    set(tasklist,MUIA_List_Quiet,FALSE);
  561. }
  562.  
  563. void SendTaskList (void) {
  564.    struct   TaskEntry   *task;
  565.  
  566.    FreeTasks();
  567.    GetTasks (&task);
  568.  
  569.    while (task) {
  570.       SendEncodedEntry ((UBYTE *) task, sizeof (struct TaskEntry));
  571.       task = task->ts_next;
  572.    }
  573.    FreeTasks();
  574. }
  575.  
  576. void GetTaskMore (struct Task *task) {
  577.    unsigned char     *title = "TASK: ";
  578.    struct   WinFree  *ptr;
  579.  
  580.    if (ptr = AllocWinFree()) {
  581.       ptr->wf_Window = (APTR) WindowObject,
  582.  
  583. //      MUIA_Window_SizeGadget, FALSE,
  584.       MUIA_HelpNode, TasksText,
  585.       MUIA_Window_ID, MakeDetailID('.','T','A','S'),
  586.       WindowContents, HGroup,
  587.          Child, VGroup, MUIA_Group_SameWidth, TRUE,
  588.             Child, MyLabel2 ("Name:"),
  589.             Child, MyLabel2 ("Address:\nIDNestCnt:\nTrapAlloc:\nTrapAble:\nTrapData:\nTrapCode:\nUserData:"),
  590.             Child, MyLabel2 ("Flags:"),
  591.          End,
  592.          Child, VGroup, MUIA_Group_SameWidth, TRUE,
  593.             Child, taskmoretext0 = MyTextObject(),
  594.             Child, HGroup,
  595.                Child, VGroup,
  596.                   Child, taskmoretext1a = MyTextObject2(),
  597.                   Child, taskmoretext1b = KeyButtonF ('b', task->tc_Flags),
  598.                End,
  599.                Child, MyLabel ("State:\nTDNestCnt:\nExceptData:\nExceptCode:\nStackSize:\nSPLower:\nSPUpper:\nSPReg:"),
  600.                Child, taskmoretext2 = MyTextObject2(),
  601.                Child, MyLabel ("Pri:\nSigAlloc:\nSigWait:\nSigRecvd:\nSigExcept:\nSwitch():\nLaunch():\nMemEntry:"),
  602.                Child, taskmoretext3 = MyTextObject2(),
  603.             End,
  604.          End,
  605.       End, End;
  606.  
  607.       if (ptr->wf_Window) {
  608.          MySetContents (taskmoretext1a, ESC "r $%08x\n%d\n$%04x\n$%04x\n $%08x\n $%08x\n $%08x", task, task->tc_IDNestCnt, task->tc_TrapAlloc, task->tc_TrapAble, task->tc_TrapData, task->tc_TrapCode, task->tc_UserData);
  609.          MySetContents (taskmoretext2, ESC "c%s\n" ESC "r%d\n$%08x\n$%08x\n%d\n$%08x\n$%08x\n$%08x", GetTaskState ((BYTE) task->tc_State), task->tc_TDNestCnt, task->tc_ExceptData, task->tc_ExceptCode, (char *) task->tc_SPUpper - (char *) task->tc_SPLower, task->tc_SPLower, task->tc_SPUpper, task->tc_SPReg);
  610.          MySetContents (taskmoretext3, ESC "r%d\n$%08x\n$%08x\n$%08x\n$%08x\n$%08x\n$%08x\n$%08x", task->tc_Node.ln_Pri, task->tc_SigAlloc, task->tc_SigWait, task->tc_SigRecvd, task->tc_SigExcept, task->tc_Switch, task->tc_Launch, task->tc_MemEntry);
  611.  
  612.          HandleFlagsButtonPressed (taskmoretext1b, ptr, "(TASK)", "tc_Flags", task->tc_Flags, (struct LongFlag *) &tc_flags, NULL, 'b');
  613.          HandleWindowOpen (ptr, title, GetTaskName (task));
  614.          MySetContents (taskmoretext0, "%s", GetTaskName (task));
  615.          HandleWindowClose (ptr);
  616.       }
  617.    }
  618. }
  619.  
  620. __asm LONG procmore_dspfunc(register __a2 char **array, register __a1 struct HunkEntry *hunkentry, register __a0 struct Hook *hook) {
  621.    if (hunkentry) {
  622.       *array++ = hunkentry->he_lower;
  623.       *array++ = hunkentry->he_upper;
  624.       *array++ = hunkentry->he_size;
  625.       *array   = NULL;
  626.    } else {
  627.       *array++ = ESC "bLower";
  628.       *array++ = ESC "bUpper";
  629.       *array++ = ESC "bSize";
  630.       *array++ = NULL;
  631.    }
  632.    return (0);
  633. }
  634.  
  635. struct Hook procmore_dsphook = {
  636.  {NULL, NULL},
  637.  (ULONG (* )())procmore_dspfunc,
  638.  NULL, NULL
  639. };
  640.  
  641. void GetSegList (struct Process *proc, struct Remember **remkey) {
  642.    struct HunkEntry  *hunkentry;
  643.    long  *seg;
  644.    long  size;
  645.  
  646.    set(procmorelist,MUIA_List_Quiet,TRUE);
  647.  
  648.    if (((seg = (long *) (((long) *((long *) (((long) proc->pr_SegList<<2) + 12)))<<2)) && points2ram((APTR) seg)) || \
  649.       ((proc->pr_CLI) && (seg = (long *) (((struct CommandLineInterface *) (proc->pr_CLI<<2))->cli_Module<<2)))) {
  650.  
  651.       while ((seg) && (hunkentry = AllocRemember (remkey, sizeof (struct HunkEntry), MEMF_ANY|MEMF_CLEAR))) {
  652.          sprintf (hunkentry->he_lower, "$%08lx", ((char *) seg) + 4);
  653.          size = *(seg - 1);
  654.          sprintf (hunkentry->he_size, "%ld", size);
  655.          sprintf (hunkentry->he_upper, "$%08lx", ((char *) seg) - 4 + size);
  656.  
  657.          InsertBottomEntry (procmorelist, (APTR *) &hunkentry);
  658.          seg = (long *) ((*seg)<<2);
  659.       }
  660.    }
  661.  
  662.    set(procmorelist,MUIA_List_Quiet,FALSE);
  663. }
  664.  
  665. void GetProcessMore (struct Process *proc) {
  666.    unsigned char     *title = "PROCESS: ";
  667.    unsigned char     tasknum[4];
  668.    struct   WinFree  *ptr;
  669.  
  670.    if (ptr = AllocWinFree()) {
  671.       ptr->wf_Window = (APTR) WindowObject,
  672.  
  673. //      MUIA_Window_SizeGadget, FALSE,
  674.       MUIA_HelpNode, TasksText,
  675.       MUIA_Window_ID, MakeDetailID('.','T','A','S'),
  676.       WindowContents, HGroup,
  677.          Child, VGroup, MUIA_Group_SameWidth, TRUE,
  678. #ifndef WINDOW_PROBLEMS
  679.             Child, MyLabel2 ("Name:"),
  680. #endif
  681.             Child, MyLabel2 ("Address:\nIDNestCnt:\nTrapAlloc:\nTrapAble:\nTrapData:\nTrapCode:\nUserData:"),
  682.             Child, MyLabel2 ("Flags:"),
  683.             Child, MyLabel2 ("Pad:\nGlobVec:\nResult2:\nCOS:\nCLI:\nWindowPtr:"),
  684.             Child, MyLabel2 ("\nHunks:\n\n\n\n"),
  685.             Child, MyVSpace(0),
  686.          End,
  687.          Child, VGroup, MUIA_Group_SameWidth, TRUE,
  688. #ifndef WINDOW_PROBLEMS
  689.             Child, processmoretext0 = MyTextObject(),
  690. #endif
  691.             Child, HGroup,
  692.                Child, VGroup,
  693.                   Child, HGroup,
  694.                      Child, VGroup, MUIA_Group_SameWidth, TRUE, MUIA_Weight, 0,
  695.                         Child, processmoretext1a = MyTextObject(),
  696.                         Child, processmoretext1b = KeyButtonF ('b', ((struct Task *) proc)->tc_Flags),
  697.                         Child, processmoretext4 = MyTextObject(),
  698.                      End,
  699. //                     Child, MyHSpace(0),
  700.                      Child, VGroup, MUIA_Group_SameWidth, TRUE, MUIA_Weight, 60,
  701.                         Child, MyLabel ("State:\nTDNestCnt:\nExceptData:\nExceptCode:\nStackSize:\nSPLower:\nSPUpper:\nSPReg:"),
  702.                         Child, MyVSpace(0),
  703.                         Child, MyLabel ("SegList:\nTaskNum:\nCurrentDir:\nConsoleTask:\nReturnAddr:\nHomeDir:"),
  704.                      End,
  705.                      Child, VGroup, MUIA_Group_SameWidth, TRUE,
  706.                         Child, processmoretext2 = MyTextObject2(),
  707.                         Child, MyVSpace(0),
  708.                         Child, processmoretext5 = MyTextObject2(),
  709.                      End,
  710.                   End,
  711.                   Child, MyVSpace(2),
  712.                   Child, procmorelist = ListviewObject,
  713.                      MUIA_Listview_DoubleClick, TRUE,
  714.                      MUIA_Listview_Input, FALSE,
  715.                      MUIA_Listview_List, ListObject,
  716.                      MUIA_List_Format, "COL=0 DELTA=8,COL=1 DELTA=8,COL=2 P=\33r",
  717.                      MUIA_List_Title, TRUE,
  718.                      MUIA_List_DisplayHook, &procmore_dsphook,
  719.                      ReadListFrame,
  720.                   End, End,
  721.                End,
  722. //               Child, MyHSpace(0),
  723.                Child, VGroup, MUIA_Group_SameWidth, TRUE, MUIA_Weight, 60,
  724.                   Child, MyLabel ("Pri:\nSigAlloc:\nSigWait:\nSigRecvd:\nSigExcept:\nSwitch():\nLaunch():\nMemEntry:"),
  725.                   Child, MyLabel ("Flags:"),
  726.                   Child, MyLabel ("StackSize:\nStackBase:\nCIS:\nFileSystemTask:\nPktWait:"),
  727.                   Child, MyLabel ("ExitCode:\nExitData:\nArguments:\nLocalVars:\nShellPrivate:\nCES:"),
  728.                End,
  729.                Child, VGroup, MUIA_Group_SameWidth, TRUE,
  730.                   Child, processmoretext3 = MyTextObject2(),
  731.                   Child, processmoretext6b = KeyButtonF ('l', proc->pr_Flags),
  732.                   Child, processmoretext6a = MyTextObject2(),
  733.                   Child, processmoretext7 = MyTextObject2(),
  734.                End,
  735.             End,
  736.          End,
  737.       End, End;
  738.  
  739.       if (ptr->wf_Window) {
  740.          MySetContents (processmoretext1a, ESC "r$%08x\n%d\n$%04x\n$%04x\n$%08x\n$%08x\n$%08x", proc, proc->pr_Task.tc_IDNestCnt, proc->pr_Task.tc_TrapAlloc, proc->pr_Task.tc_TrapAble, proc->pr_Task.tc_TrapData, proc->pr_Task.tc_TrapCode, proc->pr_Task.tc_UserData);
  741.          MySetContents (processmoretext2, ESC "c%s\n" ESC "r%d\n$%08x\n$%08x\n%d\n$%08x\n$%08x\n$%08x", GetTaskState ((BYTE) proc->pr_Task.tc_State), proc->pr_Task.tc_TDNestCnt, proc->pr_Task.tc_ExceptData, proc->pr_Task.tc_ExceptCode, (char *) proc->pr_Task.tc_SPUpper - (char *) proc->pr_Task.tc_SPLower, proc->pr_Task.tc_SPLower, proc->pr_Task.tc_SPUpper, proc->pr_Task.tc_SPReg);
  742.          MySetContents (processmoretext3, ESC "r%d\n$%08x\n$%08x\n$%08x\n$%08x\n$%08x\n$%08x\n$%08x", proc->pr_Task.tc_Node.ln_Pri, proc->pr_Task.tc_SigAlloc, proc->pr_Task.tc_SigWait, proc->pr_Task.tc_SigRecvd, proc->pr_Task.tc_SigExcept, proc->pr_Task.tc_Switch, proc->pr_Task.tc_Launch, proc->pr_Task.tc_MemEntry);
  743.          MySetContents (processmoretext4, ESC "r$%04x\n$%08x\n$%08x\n$%08x\n$%08x\n$%08x", proc->pr_Pad, proc->pr_GlobVec, proc->pr_Result2, ((ULONG) proc->pr_COS)<<2, ((ULONG) proc->pr_CLI)<<2, proc->pr_WindowPtr);
  744.  
  745.          GetTaskNumber ((struct Task *) proc, tasknum);
  746.  
  747.          MySetContents (processmoretext5, ESC "r$%08x\n%s\n$%08x\n$%08x\n$%08x\n$%08x", ((ULONG) proc->pr_SegList)<<2, tasknum, ((ULONG) proc->pr_CurrentDir)<<2, proc->pr_ConsoleTask, proc->pr_ReturnAddr, ((ULONG) proc->pr_HomeDir)<<2);
  748.          MySetContents (processmoretext6a, ESC "r%d\n$%08x\n$%08x\n$%08x\n$%08x", proc->pr_StackSize, ((ULONG) proc->pr_StackBase)<<2, ((ULONG) proc->pr_CIS)<<2, proc->pr_FileSystemTask, proc->pr_PktWait);
  749.  
  750.          MySetContents (processmoretext7, ESC "r$%08x\n$%08x\n$%08x\n$%08x\n$%08x\n$%08x", proc->pr_ExitCode, proc->pr_ExitData, proc->pr_Arguments, proc->pr_LocalVars, proc->pr_ShellPrivate, ((ULONG) proc->pr_CES)<<2);
  751.  
  752.          GetSegList (proc, &ptr->wf_RememberKey);
  753.  
  754.          HandleFlagsButtonPressed (processmoretext1b, ptr, "(PROCESS)", "tc_Flags", ((struct Task *) proc)->tc_Flags, (struct LongFlag *) &tc_flags, NULL, 'b');
  755.          HandleFlagsButtonPressed (processmoretext6b, ptr, "(PROCESS)", "pr_Flags", proc->pr_Flags, (struct LongFlag *) &pr_flags, NULL, 'l');
  756.          HandleWindowOpen (ptr, title, GetTaskName ((struct Task *) proc));
  757.          set (ptr->wf_Window,MUIA_Window_ActiveObject,procmorelist);
  758. #ifndef WINDOW_PROBLEMS
  759.          MySetContents (processmoretext0, "%s", GetTaskName ((struct Task *) proc));
  760. #endif
  761.          HandleWindowClose (ptr);
  762.       }
  763.    }
  764. }
  765.  
  766.